Perhaps you could use https://doc.rust-lang.org/std/collections/hash_map/enum.Entry.html#method.or_insert

If you replaced the get above with this entry call, it might improve the performance further by eliminating a branch perhaps??

Hmm, then we need to use or_insert_with like

let re = patterns.entry(pattern).or_insert_with(|| {
  Regex::new(pattern.as_str()).map_err(|e| {
    ArrowError::ComputeError(format!(
      "Regular expression did not compile: {e:?}"
    ))
  }?)
});

But or_insert_with cannot propagate the error out of the function.

Tried with Result<Regex, ArrowError> as value type with the patterns HashMap, but then it doesn't work because the ? operator cannot be applied to type &mut Result<regex::Regex, arrow_schema::ArrowError> too.

So just keep it as is.

Entry is an enumeration you can match on, you don't have to use or_insert_with and friends, they're just utilities like on Option

Oh, the branch to eliminate is the one inside or_insert? Do you mean something like:

let entry = patterns.entry(pattern.clone());
let re = match entry {
  Entry::Occupied(entry) => entry.into_mut(),
  Entry::Vacant(entry) => {
    let re = Regex::new(pattern.as_str()).map_err(|e| {
      ArrowError::ComputeError(format!(
        "Regular expression did not compile: {e:?}"
      ))
    })?;
    entry.insert(re)
  }
};

Hmm, it actually gets regression a little. 🤔

regexp                  time:   [7.6891 ms 7.7210 ms 7.7511 ms]
                        change: [+14.792% +15.570% +16.321%] (p = 0.00 < 0.05)
                        Performance has regressed.

That is what I meant, perhaps the regression is because of the added clone (which i think can be removed)

clone? You mean let entry = patterns.entry(pattern.clone());? It cannot be removed.

216 |                 (Some(value), Some(pattern)) => {
    |                                    ------- move occurs because `pattern` has type `String`, which does not implement the `Copy` trait
217 |                     let entry = patterns.entry(pattern);
    |                                                ------- value moved here
...
221 |                             let re = Regex::new(pattern.as_str()).map_err(|e| {
    |                                                 ^^^^^^^ value borrowed here after move
    |
help: consider cloning the value if the performance cost is acceptable
    |
217 |                     let entry = patterns.entry(pattern.clone());
    |                                                       ++++++++

Oh because of the unfortunate way flags are handled... Yeah this kernel would probably do with redesigning 😅